package com.example.api.controller;

import com.example.api.common.core.CommonResult;
import com.example.api.common.redis.ZiDeRedisUtil;
import com.example.api.entity.Card;
import com.example.api.service.CardService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/api/cards")
public class CardController {

    @Autowired
    private CardService cardService;

    @Autowired
    private ZiDeRedisUtil redisUtil;

    // Redis键定义
    private static final String ALL_CARDS_KEY = "cards:all";
    private static final String SINGLE_CARD_KEY_PREFIX = "card:";

    /**
            * 获取所有卡片（带缓存）
            */
    @GetMapping
    public CommonResult getAllCards() {
        // 1. 先尝试从Redis获取缓存
        List<Card> cachedCards = redisUtil.getCacheList(ALL_CARDS_KEY);
        if (cachedCards != null && !cachedCards.isEmpty()) {
            return CommonResult.success("成功从缓存获取数据", cachedCards);
        }

        // 2. 缓存不存在则查询数据库
        List<Card> cards = cardService.list();

        // 3. 将查询结果存入Redis（设置1小时过期时间）
        if (cards != null && !cards.isEmpty()) {
            redisUtil.setCacheList(ALL_CARDS_KEY, cards);
            redisUtil.expire(ALL_CARDS_KEY, 1, TimeUnit.HOURS);
        }

        return CommonResult.success("成功从数据库获取数据", cards);
    }

    /**
            * 根据ID查询卡片
     */
    @GetMapping("/{cardId}")
    public CommonResult getCardById(@PathVariable Integer cardId) {
        String redisKey = SINGLE_CARD_KEY_PREFIX + cardId;

        // 1. 先尝试从Redis获取缓存
        Card cachedCard = redisUtil.getCacheObject(redisKey);
        if (cachedCard != null) {
            return CommonResult.success("成功从缓存获取卡片", cachedCard);
        }

        // 2. 缓存不存在则查询数据库
        Card card = cardService.getById(cardId);
        if (card == null) {
            return CommonResult.error("卡片不存在");
        }

        // 3. 将查询结果存入Redis（设置1小时过期时间）
        redisUtil.setCacheObject(redisKey, card, 1, TimeUnit.HOURS);
        return CommonResult.success("成功获取卡片", card);
    }

    /**
            * 新增卡片（清除缓存）
            */
    @PostMapping
    public CommonResult addCard(@RequestBody Card card) {
        boolean success = cardService.save(card);
        if (!success) {
            return CommonResult.error("卡片添加失败");
        }

        // 清除所有卡片缓存（保证数据一致性）
        redisUtil.deleteObject(ALL_CARDS_KEY);
        return CommonResult.success("卡片添加成功");
    }

    /**
            * 修改卡片（清除缓存）
            */
    @PutMapping
    public CommonResult updateCard(@RequestBody Card card) {
        if (card.getCardId() < 0) {
            return CommonResult.error("卡片ID不能小于0");
        }

        boolean success = cardService.updateById(card);
        if (!success) {
            return CommonResult.error("卡片更新失败");
        }

        // 清除相关缓存
        redisUtil.deleteObject(ALL_CARDS_KEY); // 清除列表缓存
        redisUtil.deleteObject(SINGLE_CARD_KEY_PREFIX + card.getCardId()); // 清除单条缓存
        return CommonResult.success("卡片更新成功");
    }

    /**
            * 删除卡片（清除缓存）
            */
    @DeleteMapping("/{cardId}")
    public CommonResult deleteCard(@PathVariable Integer cardId) {
        boolean success = cardService.removeById(cardId);
        if (!success) {
            return CommonResult.error("卡片删除失败");
        }

        // 清除相关缓存
        redisUtil.deleteObject(ALL_CARDS_KEY); // 清除列表缓存
        redisUtil.deleteObject(SINGLE_CARD_KEY_PREFIX + cardId); // 清除单条缓存
        return CommonResult.success("卡片删除成功");
    }
}